package pe.com.cotelasa.scp.controlador;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

import javax.faces.event.ActionEvent;
import javax.inject.Inject;
import javax.inject.Named;

import org.apache.log4j.Logger;
import org.hibernate.Hibernate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import pe.com.cotelasa.scp.entidad.ParametroDetalle;

import pe.com.cotelasa.common.controlador.MBGenerico;
import pe.com.cotelasa.scp.common.IObserver;
import pe.com.cotelasa.scp.common.ISubject;
import pe.com.cotelasa.scp.controlador.backingBean.BKCompDirLocProv;
import pe.com.cotelasa.scp.controlador.backingBean.BKCompDirLocProv.SedeSubjectWrapper;
import pe.com.cotelasa.scp.dominio.common.ESTADO_REGISTRO;
import pe.com.cotelasa.scp.dominio.excepcion.ServiceException;
import pe.com.cotelasa.scp.dominio.service.IServicioEmpresa;
import pe.com.cotelasa.scp.dominio.service.IServicioParametro;
import pe.com.cotelasa.scp.dominio.service.IServicioProveedor;
import pe.com.cotelasa.scp.dominio.service.IServicioSede;
import pe.com.cotelasa.scp.entidad.Empresa;
import pe.com.cotelasa.scp.entidad.Proveedor;
import pe.com.cotelasa.scp.entidad.Sede;
import pe.com.cotelasa.scp.to.ProveedorTO;
import pe.com.cotelasa.seguridad.controlador.backingBean.BKSession;

@SuppressWarnings("serial")
@Named(value = "MBCompDirLocProv")
@Scope("request")
public class MBCompDirLocProv extends MBGenerico implements Serializable, ISubject {

    private static Logger logger = Logger.getLogger(MBGuiaDeRemision.class);
    @Inject
    private BKCompDirLocProv bkCompDirLocProv;
    @Inject
    private IServicioParametro servicioParametro;
    @Inject
    private IServicioProveedor servicioProveedor;
    @Inject
    private IServicioSede servicioSede;
    @Inject
    private IServicioEmpresa servicioEmpresa;
    @Autowired
    BKSession session;

    public void initialisation(ActionEvent actionEvent) {
        Proveedor proveedor = (Proveedor) actionEvent.getComponent().getAttributes().get("proveedorID");
        String esEmpresa = (String) actionEvent.getComponent().getAttributes().get("esEmpresa");
        bkCompDirLocProv.setListaLocProv(new ArrayList<Sede>());
        bkCompDirLocProv.setListaProveedores(new ArrayList<ProveedorTO>());
        bkCompDirLocProv.setIdTipoProveedorBusqueda("");
        cargarCombo();
        if (proveedor != null) {
            try {
                bkCompDirLocProv.setProveedorBusqueda(proveedor);
                bkCompDirLocProv.setListaLocProv(servicioSede.listaSedePorProveedor(proveedor));
            } catch (ServiceException e) {
                logger.error(e.getMessage(), e);
                mostrarError("Ocurrio un error al cargar la informacion.");
            }
        } else {
            if(esEmpresa.equals("si")){
                bkCompDirLocProv.setListaLocProv(bkCompDirLocProv.getSedesPorEmpresa());
            }   
            
            bkCompDirLocProv.setProveedorBusqueda(new Proveedor());
        }
    }

    private void cargarCombo() {
        try {
            bkCompDirLocProv.setSedesPorEmpresa(new ArrayList<Sede>());
            bkCompDirLocProv.setListaTipoProveedor(servicioParametro.listarTipoProveedorActivos());
            bkCompDirLocProv.setListaALLProveedores(servicioProveedor.listarProveedorPorTipo());
            for(Sede sede: servicioEmpresa.conseguirEmpresaPorId(session.getEmpresa().getId()) .getSedeCollection()){
                if(sede.getEsAlmacen() == 1 && sede.getEstadoRegistro() == ESTADO_REGISTRO.ACTIVO.getValor()){
                    bkCompDirLocProv.getSedesPorEmpresa().add(sede);
                }
            }
            
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public void buscarProveedorPorTipo() {
        String tipoProveedor = bkCompDirLocProv.getIdTipoProveedorBusqueda();
        List<ProveedorTO> listProv = new ArrayList<ProveedorTO>();
        bkCompDirLocProv.setEnableCbxProveedor(false);
        if (tipoProveedor.equalsIgnoreCase("S")) {
            for (ProveedorTO to : bkCompDirLocProv.getListaALLProveedores()) {
                if (to.getTipo_servicio().equalsIgnoreCase(tipoProveedor)) {
                    listProv.add(to);
                }
            }
        } else {
            if (tipoProveedor.equalsIgnoreCase("I")) {
                for (ProveedorTO to : bkCompDirLocProv.getListaALLProveedores()) {
                    if (to.getTipo_insumo().equalsIgnoreCase(tipoProveedor)) {
                        listProv.add(to);
                    }
                }
            } else {
                if (tipoProveedor.equalsIgnoreCase("C")) {
                    bkCompDirLocProv.setEnableCbxProveedor(true);
                } else {
                    mostrarWarning("Es obligatorio elegir un tipo de proveedor.");
                }
            }
        }
        bkCompDirLocProv.setProveedorBusqueda(new Proveedor());
        bkCompDirLocProv.setListaProveedores(new ArrayList<ProveedorTO>());
        bkCompDirLocProv.setListaProveedores(listProv);
    }

    public void buscarLocalesDelProveedor(ActionEvent actionEvent) {
        try {
            bkCompDirLocProv.setListaLocProv(new ArrayList<Sede>());
            String tipoProveedor = bkCompDirLocProv.getIdTipoProveedorBusqueda();
            if (tipoProveedor.equalsIgnoreCase("C")) {
                bkCompDirLocProv.setListaLocProv(bkCompDirLocProv.getSedesPorEmpresa());
            } else {
                if (bkCompDirLocProv.getProveedorBusqueda() != null) {
                    Proveedor proveedor = servicioProveedor.conseguirProveedorConUbigeo(bkCompDirLocProv.getProveedorBusqueda().getId());
                    for (Sede se : proveedor.getSedeCollection()) {
                        if (se.getEstadoRegistro() == ESTADO_REGISTRO.ACTIVO.getValor()) {
                            bkCompDirLocProv.getListaLocProv().add(se);
                        }
                    }

                } else {
                    mostrarError("Debe ingresar todos los fitros de la busqueda.");
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public Collection<Proveedor> buscarProveedor(String proveedorABuscar) {
        Collection<Proveedor> listaProveerdorEncontrados = new ArrayList<Proveedor>();
        for (ProveedorTO to : bkCompDirLocProv.getListaProveedores()) {
            if (to.getRazon_social().startsWith(proveedorABuscar)) {
                Proveedor proveedor = new Proveedor();
                proveedor.setId(to.getId());
                proveedor.setRazonSocial(to.getRazon_social());
                listaProveerdorEncontrados.add(proveedor);
            }
        }
        return listaProveerdorEncontrados;
    }

    @Override
    public void addObserver(IObserver observador) {
        bkCompDirLocProv.addObservers(observador);
    }

    public void aceptar(String idObserver) {
        bkCompDirLocProv.getSubject().setIdObserver(idObserver);
        notificarObservadores();
    }

    @Override
    public void notificarObservadores() {
        try {
            for (IObserver observer : bkCompDirLocProv.getObservers()) {
                observer.actualizarObservador(bkCompDirLocProv.getSubject());
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public void reset() {
        bkCompDirLocProv.setIdTipoProveedorBusqueda("");
        bkCompDirLocProv.setProveedorBusqueda(null);
        bkCompDirLocProv.setListaALLProveedores(new ArrayList<ProveedorTO>());
        bkCompDirLocProv.setListaLocProv(new ArrayList<Sede>());
        bkCompDirLocProv.setListaProveedores(new ArrayList<ProveedorTO>());
        bkCompDirLocProv.setEnableCbxProveedor(true);
        bkCompDirLocProv.setSedesPorEmpresa(new ArrayList<Sede>());
        bkCompDirLocProv.initSedeSubject();
    }
}
